package com.algorithm.example;

import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.Iterator;
import java.util.function.Consumer;
import java.util.stream.IntStream;

/**
 * <p>
 * 数组
 * </p>
 *
 * @author lzt
 * @version 1.0
 * @since 2024/1/18 11:31
 */
@Component
public class Array implements Iterable<Integer> {
    /**
     * 逻辑大小
     */
    private int size = 0;

    /**
     * 容量
     */
    private int capacity = 8;

    /**
     * 静态数组
     */
    private int[] array = {};


    /**
     * 向[0...size]位置添加数据
     */
    public void addLast(int element) {
        add(size, element);
    }

    /**
     * 返回索引元素
     */
    public int get(int index) {
        return array[index];
    }

    /**
     * 删除索引元素，并返回索引元素
     */
    public int remove(int index) {
        int remove = array[index];
        if (index < size - 1) {
            // 索引之后的元素向前移动
            System.arraycopy(array, index + 1, array, index, size - index - 1);
        }
        size--;
        return remove;
    }

    /**
     * 在index - 索引位置   向[0...size]位置添加数据
     */
    public void add(int index, int element) {
        extracted();
        if (index >= 0 && index < size) { // 保证了无需要处理未赋值的数据
            System.arraycopy(array, index, array, index + 1, size - index);
        }
        array[index] = element;
        size++;
    }

    /**
     * 扩容
     */
    private void extracted() {
        if (size == 0) { // 懒惰初始化
            array = new int[capacity];
        }
        if (capacity == size) {
            capacity += capacity >>> 1;
            int[] newArray = new int[capacity];
            System.arraycopy(array, 0, newArray, 0, size);
            array = newArray;
        }
    }

    /**
     * 遍历数据
     * 函数式接口 Consumer ，将数据的处理方式交给调用者
     */
    public void foreach(Consumer<Integer> consumer) {
        for (int i = 0; i < array.length; i++) {
            consumer.accept(array[i]);
        }
    }

    /**
     * 迭代式遍历
     */
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int i = 0;

            @Override
            public boolean hasNext() { // 查询有没有下一个元素 自动调用
                return i < size;
            }

            @Override
            public Integer next() { // 返回当前元素 自动调用
                return array[i++];
            }
        };
    }

    /**
     * 流式遍历
     */
    public IntStream stream() {
        return IntStream.of(Arrays.copyOfRange(array, 0, size));
    }
}
